Installation des packages

installer les packages suivants ….. + version min

install.packages(knitr)
install.packages(sf)
install.packages(mapsf)
install.packages(packcircles)
install.packages(cartogram)
install.packages(recmap)
install.packages("https://cran.r-project.org/src/contrib/Archive/cartogramR/cartogramR_1.0-1.tar.gz", repos = NULL, type = "source")

Import et mise en forme des données

données INSEE (pop + CSP en 2018)

Le package sf bla bla bla…..

library(sf)
communes <- st_read("data/isere.geojson", quiet = TRUE ) %>% st_transform(2154)
data <- read.csv("data/popisrere.csv",  dec = ",")
communes = merge(x = communes[,c("id","name","geometry")], 
                 y = data[,c("id", "pop2018","agri", "art", "cadr", "interm", "emp","ouvr","retr")],
                 by = "id")
isere = st_union(communes)

knitr::kable(communes[c(0:10),], row.names = F, digits = 1)

Rappel en carto “classique” avec le package mapsf

Le package mapsf permet de faire des cartes thématiques dans R. C’est le package qui succède au package cartography.

Trois solutions existent pour cartographier des quantités brutes associées à des surfaces en cartographie dite “classique” : la dot map, les points valués et les symboles proportionnels.

NICO XXXX Je te propose de changer l’ordre pour avoir les cercles prop en dernier et faire transition avec packcircle

library(mapsf)

col = "#c291bc"
credits = paste0("Bronner Anne-Christine & Nicolas Lambert, 2021\n",
                  "Source: IGN & INSEE, 2021")
theme = mf_theme(x = "default", bg = "#f0f0f0", tab = FALSE, 
                   pos = "center", line = 2, inner = FALSE, 
                   fg = col, mar = c(0,0, 2, 0),cex = 1.9)

template = function(title, file, note = "", basemap = TRUE, scale = TRUE){
  
  mf_export(
    communes,
    export = "png",
    width = 1000,
    filename = file,
    res = 96,
    theme = theme, 
    expandBB = c(-.02,0,-.02,0)
  )
  
  if (basemap == TRUE){
    mf_shadow(x = communes, col = "grey50", cex = 1, add = TRUE)
    mf_map(communes, col ="#CCCCCC", border = "white", lwd = 0.5, add = TRUE)
  }
  
  mf_title(title)
  
  if (scale == TRUE){
    mf_scale(size = 20, pos = "bottomright", lwd = 1.2, cex = 1, col = "#383838", unit = "km")
  }
  
  mf_credits(
    txt = credits,
    pos = "bottomleft",
    col = "#1a2640",
    cex = 0.8,
    font = 3,
    bg = "#ffffff30"
  )
  
if(note != ""){
  mf_annotation(
    x = c(885000, 6435000),
    txt = note,
    pos = "bottomleft", cex = 1.2, font = 2,
    halo = TRUE, s = 1.5
)
  }

}

template("Template cartographique", "maps/template.png", note = "Département de\nl'Isère (38)")
mf_map(communes, col = col, border = "white", lwd = 0.5, add = TRUE)
dev.off()

dotdensitymap <- function(x, var, onedot = 1, radius = 1){
x <- x[,c("id",var,"geometry")]
x[,"v"] <- round(x[,var] %>% st_drop_geometry() /onedot,0)
dots <- st_sample(x, x$v, type = "random", exact = TRUE)
circles <- st_buffer(dots, dist = radius)
return (circles)
}

onedot = 500
dots = dotdensitymap(x = communes, var = "pop2018", onedot = onedot, radius = 300)
template("Carte par points", "maps/dotdensity.png", note = paste0("Un point =\n",onedot," habitants"))
mf_map(dots, col = col, border = "#520a2c", lwd = 0.5, add = TRUE)
dev.off()

if(!file.exists("files/grid.gpkg")){
  
  grid = st_make_grid(communes, cellsize = 1000, square = TRUE)
  grid = st_sf(id = c(1:length(grid)), geometry = grid)
  ids = communes[,"id"] %>% st_drop_geometry()
  ctr = st_centroid(grid)

  for(i in 1:nrow(grid)){
  x = st_within(x = ctr[i,], y = communes, sparse = TRUE, prepared = TRUE)
  id = ids[unlist(x),][1]
  if (length(id) == 0){id = NA}
  grid[i,"id"] = id
}

grid <- grid[!is.na(grid$id),]

for(i in 1:nrow(grid)){
  id = as.character(grid[i,"id"])[1]
  popAll = as.numeric(communes[communes$id == id,"pop2018"] %>% st_drop_geometry())
  count = nrow(grid[grid$id == id,])
  grid[i,"pop"] = popAll / count
}  

st_write(grid,"files/grid.gpkg", delete_layer=TRUE)
} else {
  grid = st_read("files/grid.gpkg")
}

template("Points Bertin (grosso modo)", "maps/pointsbertin.png")
mf_map(communes, col = "#CCCCCC", border = "white", lwd = 0.5, add = FALSE)
mf_map(grid, var = "pop", col = col, border = "#520a2c", type = "prop",
       inches = 0.07, leg_title_cex = 1.2, leg_val_cex  = 0.8,
       leg_title = "Nombre d'habitants, 2018")

dev.off()

template("Symboles proportionnels (mapsf)", "maps/prop2.png")
mf_map(communes, var = "pop2018", col = col, border = "#6b4266", type = "prop",
       inches = 0.8, leg_title_cex = 1.2, leg_val_cex   = 0.8, symbol = "square",
       leg_title = "Nombre d'habitants, 2018")
dev.off()

template("Symboles proportionnels (mapsf)", "maps/prop.png")
mf_map(communes, var = "pop2018", col = col, border = "#6b4266", type = "prop",
       inches = 0.8, leg_title_cex = 1.2, leg_val_cex   = 0.8,
       leg_title = "Nombre d'habitants, 2018")
dev.off()

Le cartogramme circulaire de Dorling avec le package packcircles

Le package packcirles propose 3 algorithmes simples pour déplacer des disques sur un plan 2D de telle sorte qu’ils ne se supperposent pas. Nous pouvons l’utiliser pour créer des cartogrammes de Dorling (Dorling 1996).

Création d’un ficher de données simplifié avec les coordonnées des centroïdes des communes.

dots = communes
st_geometry(dots) <- st_centroid(sf::st_geometry(dots),of_largest_polygon = TRUE)
dots <- data.frame(dots$id, dots["pop2018"], st_coordinates(dots))
dots = dots[,c("dots.id","X","Y","pop2018")]
colnames(dots) <- c("id","x","y","v")
dots <- dots[!is.na(dots$v),]
knitr::kable(dots[c(0:5),], row.names = F, digits = 1)

La fonction circleRepelLayout() prend un ensemble de cercles dans un cadre de données et utilise la répulsion itérative pour essayer de trouver un arrangement sans chevauchement où tous les centres des cercles se trouvent à l’intérieur d’un rectangle de délimitation. Si aucun arrangement de ce type ne peut être trouvé dans le nombre maximum d’itérations spécifié, la dernière tentative est renvoyée.

library("packcircles")

k = 500 # pour ajuster la taille des cercles
itermax = 10 # nombre d'iterations

dat.init <- dots[,c("x","y","v")]
dat.init$v <- sqrt(dat.init$v * k)
simulation <- circleRepelLayout(x = dat.init, xysizecols = 1:3,
                                wrap = FALSE, sizetype = "radius",
                                maxiter = itermax, weights =1)$layout
knitr::kable(simulation[c(0:5),], row.names = F, digits = 1)

circles <- st_buffer(sf::st_as_sf(simulation, coords =c('x', 'y'),
                      crs = sf::st_crs(communes)), dist = simulation$radius)
circles$v = dots$v

template("Dorling (packcircles)", "maps/dorling1.png", scale = FALSE)
mf_map(isere, col = "#CCCCCC", border = "white", lwd = 0.5, add = TRUE)
mf_map(circles,col = col, border = "#6b4266", lwd = 0.5, add = TRUE)
dev.off()

## png 
##   2

Les 3 formes classiques avec le package cartogram

le package cartogram est développé par Sebastian Jeworutzki. Il propose trois méthodes, de la plus récente à la plus ancienne (XX VALIDER XX) : le cartogramme circulaire de Dorling, continu de Dougenik, Chrisman et Niemeyer et discontinu d’Olson).

library(cartogram)

Dorling = cartogram_dorling(communes, "pop2018", k = 1.8)

template("Dorling (cartogram)", "maps/dorling2.png", scale = FALSE)
mf_map(isere, col = "#CCCCCC", border = "white", lwd = 0.5, add = TRUE)
mf_map(Dorling, col = col, border = "#6b4266", lwd = 0.5, add = TRUE)
dev.off()

Olson <- cartogram_ncont(communes, "pop2018", k = 1, inplace = TRUE)

template("Olson (cartogram)", "maps/olson.png", basemap = FALSE, scale = FALSE)
mf_map(isere, col = "#CCCCCC30", border = "white", lwd = 0.5, add = TRUE)
mf_map(Olson, col = col, border = "#6b4266", lwd = 0.5, add = TRUE)
dev.off()

Dougenik <- cartogram_cont(communes, "pop2018", prepare = "none", itermax = 10, maxSizeError = 1.15)

sumarea = sum(as.numeric(st_area(Dougenik)))
sumpop = sum(Dougenik$pop2018)
Dougenik$error = (as.numeric(st_area(Dougenik)) /  sumarea) / (Dougenik$pop2018 / sumpop) * 100
summary(Dougenik$error)

##      Min.   1st Qu.    Median      Mean   3rd Qu.      Max. 
##    0.2513   96.9756  109.4084  143.6154  130.7821 2734.5953

bks = c(min(Dougenik$error),70,80,90,100,110,120,max(Dougenik$error))
cols = c("#d53e4f", "#f46d43","#fdae61","#fee08b","#e6f598","#abdda4", "#66c2a5")

template("Dougenik (cartogram)", "maps/dougenik.png", basemap = FALSE, scale = FALSE)
mf_map(x = Dougenik, type = "choro",var = "error", pal = cols, breaks = bks, border = "#6b4266", lwd = 0.5, add = TRUE)
dev.off()

Les algos pour les cartogrammes continus avec le package cartogramR

XXX JE fais l’install.packages il compile a library il m’explique qu’elle n’existe pas …

library(cartogramR)

Le package cartogramR est développé par Pierre-Andre Cornillon et Florent Demoraes de l’université de Rennes. Le package propose les méthodes flow based cartogram (Gastner and Newman 2004) implanté dans Scapetoad, fast flow based cartogram (Gastner, Seguy, and More 2018) et rubber band based cartogram (Dougenik, Chrisman, and Niemeyer 1985). La méthode flow based cartogram est basée sur go_cart.

Attention, cartogramR n’est pas/plus sur le CRAN. L’archive est néanmoins disponible et permet l’installation.

la fonction precartogramR() aide à choisir la taille de la grille de déformation (plus elle est fine, plus le calcul sera long). On choisit donc a minima une grille telle que le minimum d’intersections est supérieur ou égal a un (ici un pas de grille de 256 peut faire l’affaire).

precarto <- precartogramR(communes, method = "GastnerSeguyMore")
summary(precarto)

##              L256      L512     L1024     L2048
## Min.      2.00000    5.0000   20.0000    82.000
## 1st Qu.  13.00000   52.0000  208.7500   837.000
## Median   19.00000   77.0000  306.0000  1226.500
## Mean     26.16992  104.6953  418.6816  1674.701
## 3rd Qu.  29.00000  115.2500  460.7500  1850.250
## Max.    405.00000 1613.0000 6469.0000 25884.000

la fonction cartogramR() permet de calculer le cartogramme en tant que tel selon les 3 méthodes proposées : GastnerSeguyMore" (ou “gsm),”GastnerNewman" (ou “gn),”DougenikChrismanNiemeyer" (ou “dcn”). L’option L=256 permet de choisir la taille de la grille. L’option grid=TRUE (pour les méthodes “gsm” et “gn”) permet d’afficher la grille de déformation. L’option maxit=50 permet de définir le nombre d’itérations max (défaut = 50).

Test de l’algorithme de Gastener et Newman de 2004, équivalent à celui implanté dans la solution java scapetoad.

xxxx Je ne sais pas si Dominique a testé Isere sur Scapetoad xxxxxx

GastnerSeguy <- cartogramR(communes, count="pop2018", method="GastnerSeguyMore", options=list(L=256, grid=TRUE, maxit = 5))

## WARNING criterion: 26.455251 > Objective: 0.010000
##  Increase maxit or decrease Objective

La fonction make_layer() permet de récupérer la grille de calcul (mais aussi la grille d’origine, les centroides, etc)

grid <- make_layer(GastnerSeguy, type = c("final_graticule"))

L’affichage des résultats peut se réaliser avec plot (via sf) ou, comme précédemment, avec le package mapsf.

template("Gastner, Seguy & More", "maps/gastnerseguy.png", basemap = FALSE, scale = FALSE)
mf_map(GastnerSeguy$cartogram, col = col, border = "white", lwd = 1, add = TRUE)
mf_map(grid, col = NA, border = "#6b4266", lwd = 0.05, add = TRUE)
dev.off()

XXXX acb (message pour moi-même ou Nico) voir si on peut arriver à l’équivalent scapetoad = afficher la légende, les erreurs, la grille. La légende serait un vrai plus) xxxx

La fonction residuals() permet de calculer les erreurs liées à la déformation (erreur relative : taille finale / taille theorique * 100)

table = cbind(GastnerSeguy$initial_data[,c("id","pop2018")] %>% st_drop_geometry(),
      orig_area = GastnerSeguy$orig_area,
      final_area = GastnerSeguy$final_area,
      errors = residuals(GastnerSeguy, type = "relative error")*100
      )
knitr::kable(table[c(0:10),], row.names = F, digits = 1)

Export au format sf

st_write(as.sf(GastnerSeguy),"files/GastnerSeguy.gpkg", delete_layer=TRUE)
# GastnerSeguy_sf = st_as_sf(table, geometry = GastnerSeguy$cartogram)
# st_write(GastnerSeguy_sf,"files/GastnerSeguy.gpkg", delete_layer=TRUE)

Dots Cartograms

La méthode des dots cartograms est une représentation cartographique à l’intersection des cartogrammes de Dorling et de la carte par points. Les premières cartes utilisant cette méthodes ont été réalisées sur les données du Covid (voir et voir). Article à paraitre. Voir aussi sur Observable

dotcartogram = function(x,var,itermax,onedot,radius){
crs = sf::st_crs(x)
coords <- st_coordinates(st_centroid(sf::st_geometry(x),of_largest_polygon = TRUE))
x <- x[c("id",var)] %>% st_drop_geometry()
x <- data.frame(x, coords)
colnames(x) <- c("id","v","x","y")
x$v <- round(x$v/onedot,0)
x <- x[x$v > 0,]
dots <- x[x$v == 1,c("x","y","v")]
rest <-  x[x$v  > 1,c("x","y","v")]

nb <- nrow(rest)
  for (i in 1:nb){
    new <- rest[i,]
    new$v <- 1
    for (j in 1:rest$v[i]){ dots <- rbind(dots,new)}
  }
  
dots$x <- jitter(dots$x)
dots$y <- jitter(dots$y)
dots$v <- radius
  
simulation <- circleRepelLayout(x = dots, xysizecols = 1:3,
                                  wrap = FALSE, sizetype = "radius",
                                  maxiter = itermax, weights =1)$layout

circles <- st_buffer(sf::st_as_sf(simulation, coords =c('x', 'y'),
                                    crs = crs), dist = radius) 
return(circles)
}

onedot = 1000
dc = dotcartogram(x = communes, var = "pop2018", itermax = 120,
                  onedot = onedot, radius = 600)

template("Dots Cartogram", "maps/dotcartogram.png", note = paste0("Un point =\n",onedot," personnes"), scale = FALSE)
mf_map(isere, col = "#CCCCCC", border = "white", lwd = 0.5, add = TRUE)
mf_map(dc, col = col, border = "#6b4266", lwd = 0.8, add = TRUE)
dev.off()

Mosaic cartogram

Ici, on essaie de reproduire les cartogrammes de type mosaïque en trichant un peu… La forme choisie est l’hexagone. On est sur un hexagonal cartogram.

On récupère un fond transformé par un algorithme de cartogramme continu

cartogram = st_read("files/GastnerSeguy.gpkg")

Création d’une grille hexagonale, récupération des identificateurs des entités

grid = st_make_grid(cartogram, cellsize = 2000, square = FALSE)
grid = st_sf(id = rep("",length(grid)), geometry = grid)
ctr = st_centroid(grid)
ids = cartogram[,"id"] %>% st_drop_geometry()

for(i in 1:nrow(grid)){
  x = st_within(x = ctr[i,], y = cartogram, sparse = TRUE, prepared = TRUE)
  id = ids[unlist(x),][1]
  if (length(id) == 0){id = NA}
  grid[i,"id"] = id
}
grid <- grid[!is.na(grid$id),]

gridcartogram <- aggregate(x = grid, 
               by = list(grid$id),
               FUN = min)

Estimation de la valeur de chaque hexagone

varmax = sum(cartogram$pop2018)
nbcell = nrow(grid)
valcell = round(varmax / nbcell)

Création de la carte

template("Template cartographique", "maps/hexcartogram.png", note = paste0("Un hexagone ≈\n",valcell," habitants"),basemap = FALSE, scale = FALSE)
mf_shadow(x = grid, col = "grey50", cex = 1, add = TRUE)
mf_map(grid, col = col, border = "white", lwd = 0.5, add = TRUE)
mf_map(gridcartogram, col = NA, border = "#6b4266", lwd = 1, add = TRUE)
dev.off()

Tu peux ajouter fastoche une petite mesure de la qualité.

the quality of the representation = scatterplot that related the number of hexagons per distorted region with the total population of the respective region + The coefficient of correlation, R2.

https://www.ralphstraumann.ch/blog/2013/05/creating-a-hexagonal-cartogram/

Hybride : tessalation et cartograme continu

NB : calculer les polygones de voronoi en R est un peu tricky. Voir et voir.

c <- st_centroid(communes)
v <- st_voronoi(x = st_union(c))
v <- st_intersection(st_cast(v), st_union(communes))
v <- st_join(x = st_sf(v), y = c, join=st_intersects)
v <- st_cast(v, "MULTIPOLYGON")

template("Polygones de voronoi", "maps/voronoi.png", basemap = FALSE, scale = FALSE)
mf_map(x = v, col = col, border = "#6b4266", lwd = 0.5, add = TRUE)
dev.off()

Ensuite, on peut calculer un cartogramme de Dougenik sur ces nouvelles géométries.

VDougenik <- cartogram_cont(v, "pop2018", prepare = "none", itermax = 10, maxSizeError = 1.15)

template("Dougenik & voronoi", "maps/dvoronoi.png", basemap = FALSE, scale = FALSE)
mf_map(x = VDougenik, col = col, border = "#6b4266", lwd = 0.5, add = TRUE)
dev.off()

A vous de jouer ! Quel package pour créer une tesselation de la zone d’étude ? Fichier entrée : les centroïdes extrait des entités surfacique et le contour de la zone pour la découpe. Le fond Voronoi peut ensuite être transformé par l’un des alorithme qui crée le cartogramme continu

L’impossibilité de réaliser un cartogramme rectangulaire avec le package recMap

A ce jour, il n’est pas possible d’automatiser la réalisation de cartogrammes de Demers ou rectangulaire, qui puissent construire et assembler un puzzle respectant surface, contiguité tout en recréant une forme globale à partir de formes carrées ou rectangulaires proportionnelles à des quantités brutes (stock).

Christian Panse a développé une première approche algorithmique que l’on trouve dans le package Recmap (Heilmann et al. 2004) (Panse 2016). L’algorithme va convertir les géométries des unités spatiales en rectangles dont la surface est définie par la variable thématique (stock). L’algorithme de RecMap est disponible ici. Développé en C++11, le package dépend des packages GA (>= 3.1), Rcpp (>= 1.0), sp(>= 1.3)

Nico, je me suis permise, comme c’est un nouveau fichier, de remplacer par l’exemple de l’Isère pour qu’on reste sur la même zone. Qu’en pense-tu

library(recmap)

Préparation des données

Création d’une fonction pour créer un fichier conforme à recmap

sfc_as_cols <- function(x, geometry, names = c("x","y")) {
  if (missing(geometry)) {
    geometry <- sf::st_geometry(x)
  } else {
    geometry <- rlang::eval_tidy(enquo(geometry), x)
  }
  stopifnot(inherits(x,"sf") && inherits(geometry,"sfc_POINT"))
  ret <- sf::st_coordinates(geometry)
  ret <- tibble::as_tibble(ret)
  stopifnot(length(names) == ncol(ret))
  x <- x[ , !names(x) %in% names]
  ret <- setNames(ret,names)
  dplyr::bind_cols(x,ret)
}

Extraction des centroïdes long-lat sous forme d’une table XY

coords <- st_centroid(communes)
coords <- st_transform(coords, crs="+proj=longlat +datum=WGS84 +ellps=WGS84")

Création du fichier pour recmap

df_recmap <- sfc_as_cols(coords)

Calcul des rectangles

rec_cartogram <- data.frame (x= df_recmap$x,
                             y=df_recmap$y,
                             # make the rectangles overlapping by correcting lines of longitude distance
                             dx = sqrt(df_recmap$pop2018) / 90 / abs((0.65 * 60 * cos(df_recmap$y*pi/180))),
                             dy = sqrt(df_recmap$pop2018) / 90 / (0.65 * 60),
                             z = sqrt(df_recmap$pop2018),
                             name = df_recmap$id)

(Nico?) Il faut que tu revoies le code pour l’affichage template je capte pas comment ça marche ce truc

# template("", "maps/recmap1.png", basemap = FALSE, scale = FALSE)
# plot.recmap(df, col = NA, border = col, lwd=4,  col.text = col)
# dev.off()

#cartog <- recmap(df)
#template("", "maps/recmap2.png", basemap = FALSE, scale = FALSE)
#plot(cartog[!cartog$name %in% c("IS","MT"),],  col = col, border = "white")
#dev.off()

Cartogramme et étendue spatiale

world <- st_read("data/world_countries.geojson", quiet = TRUE ) %>%
  st_transform( "+proj=bertin1953")

world <- world[world$ISO3 != "ATA",]

knitr::kable(world[c(0:10),], row.names = F, digits = 1)

col = "#c291bc"
credits = "Vous, 2021"
theme = mf_theme(x = "default", bg = "#f0f0f0", tab = FALSE, 
                   pos = "center", line = 2, inner = FALSE, 
                   fg = col, mar = c(0,0, 2, 0),cex = 1.9)

templateworld = function(title, file){

  mf_export(
    world,
    export = "png",
    width = 1000,
    filename = file,
    res = 96,
    theme = theme, 
    expandBB = c(-.02,0,-.02,0)
)

  mf_title(title)

  mf_credits(
    txt = credits,
    pos = "bottomleft",
    col = "#1a2640",
    cex = 0.8,
    font = 3,
    bg = "#ffffff30"
  )
}

templateworld("Le monde en projection Bertin (thx Fil)", "maps/world.png")
mf_map(world, col =col, border = "white", lwd = 0.5, add = TRUE)
dev.off()

world_sansNA = na.omit(world)

par(mfrow = c(2, 2), mar = c(0,0,0,0))
mf_map(world_sansNA)
mf_map(x=cartogram_cont(world_sansNA, "PopTotal"))
mf_map(x=cartogram_dorling(world_sansNA, "PopTotal"))
mf_map(x=cartogram_ncont(world_sansNA, "PopTotal"))

dev.off()

europe <- st_read("data/europe.geojson")

par(mfrow = c(2, 2), mar = c(0,0,0,0))
mf_map(europe)
mf_map(x=cartogram_cont(europe, "pop2008"))
mf_map(x=cartogram_dorling(europe, "pop2008"))
mf_map(x=cartogram_ncont(europe, "pop2008"))

dev.off()

Cartogramme et niveaux d’agrégation

Reprendre l’Isère (communes, cantons, arrondissement) et l’Europe

J’ai vu que tu as préparé un fond Europe pays - est-ce que éventuellement tu as le pendant en nuts 2 et nuts 1 ? Sinon j’en ai

Un mot sur l’anticartogramme

Eduardo Dutenkefer a exploré l’esthétique des cartogrammes et notamment imaginé l’anti-cartogramme, qui inverse le poids des entités : la surface varie en proportion inverse à la valeur cartographiée.

Rappel. Le cartogramme a pour objectif par la variation de taille, qui a un sens bien défini en cartographie, basé sur la perception visuelle (la surface permet d’estimer la part de chaque ou d’un groupe d’entités sur le total), de révéler les inégalités de répartition sur un territoire.

Si on s’en tient au traitement cartogramme de la donnée, l’anticartogramme ne sert à rien dans le cadre d’une analyse des inégalités territoriales. Il serait faux de dire que l’anticartogramme représenterait le contraire (excepté dans le cas où deux variables représenterait la part d’un tout : p. ex. les votes exprimés entre deux candidats, chômeurs et actifs dans la population active, situation où nous sommes de facto en présence d’une relation inverse entre les deux variables).

Représenter le non poids des lieux ? Un cartogramme de la non population ne représente pas nécessairement les zones dites rurales. A l’échelle mondiale, l’anti-cartogramme des riches n’est pas le cartogramme des pauvres. Les inégalités de répartition de la non-population, du non-PIB, du non CO2, de la même manière que la visualisation des non flux ou une carte des anti flux, où le flux le plus insignifiant devient le plus massif. Pour révéler et analyser les zones où les effectifs sont faibles, les stocks peu élevés, le traitement de la donnée s’effectue par le filtrage.

Visualiser le “non poids,” créer la “non image” d’un espace peut soutenir un discours artistique, métaphorique sur un espace et non pas à cartographier une variable quantitative.

(Poncet 2011) Je mettrais plutôt la thèse de Dutenkefer ou son article avec Padovesi Fonseca antérieures au topo de Poncet. Si j’avais eu un peu le temps je les aurais contactés car ils auraient sûrement été très intéressés par Transcarto.

Calcul de la valeur du “non phénomène” cartographié (1/)

communes$inverse = 1/communes$pop2018

# antiCartogram <- cartogram_cont(communes, "inverse", prepare = "none", itermax = 10, maxSizeError = 1.15)
# template("AntiCartogram (cartogram)", "maps/anticartogram", basemap = FALSE, scale = FALSE)
# mf_map(x = antiCartogram, type = "choro",var = "error", border = "#6b4266", lwd = 0.5, add = TRUE)
# dev.off()